#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct Node
{
    int data;           //数据域
    struct Node *pNext; //指针域
} NODE, *PNODE;         // NODE等价于struct Node  PNODE等价于struct Node *

//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE, int, int);   //哪个链表、哪个位置，什么值
bool delete_list(PNODE, int, int *); //哪个链表、哪个位置、返回要删除的值
void sort_list(PNODE);

//主函数
int main(void)
{
    PNODE pHead = NULL; //等价于struct Node * pHead = NULL;
    int val;

    pHead = create_list(); //创建一个非循环单链表，并将该链表的头结点地址赋给pHead
    traverse_list(pHead);
    if (is_empty(pHead))
    {
        printf("链表为空！\n");
    }
    else
    {
        printf("链表不为空！\n");
    }

    int len = length_list(pHead);
    printf("链表长度是%d\n", len);

    sort_list(pHead);
    traverse_list(pHead);

    insert_list(pHead, 3, 2);
    traverse_list(pHead);

    if (delete_list(pHead, 4, &val))
    {
        printf("删除成功，您删除的元素是：%d\n", val);
    }
    else
    {
        printf("删除失败\n");
    }
    traverse_list(pHead);

    return 0;
}

/*
创建一个链表的函数
*/
PNODE create_list(void)
{
    int len; //用来存放有效节点个数
    int i;
    int val; //用来临时存放用户输入的节点的值

    //分配了一个不存放有效数据的头节点
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    if (NULL == pHead)
    {
        printf("分配失败，程序终止！");
        exit(-1);
    }
    PNODE pTail = pHead; //新建一个永远指向末尾的尾节点
    pTail->pNext = NULL;

    printf("请输入您需要生成的链表节点的个数：len = ");
    scanf("%d", &len);

    for (i = 0; i < len; i++)
    {
        printf("请输入第%d个节点的值：", i + 1);
        scanf("%d", &val);

        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pNew)
        {
            printf("分配失败，程序终止！");
            exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }

    return pHead;
}

//遍历一个链表的函数
void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;

    while (NULL != p)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}

/*
判断一个链表是否为空
*/
bool is_empty(PNODE pHead)
{
    if (NULL == pHead->pNext)
    {
        return true;
    }
    else
    {
        return false;
    }
}

/*
求一个链表的长度
*/
int length_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    int len = 0;
    while (NULL != p)
    {
        ++len;
        p = p->pNext;
    }
    return len;
}

/*
对链表进行排序
*/
void sort_list(PNODE pHead)
{
    int i, j, t;
    PNODE p, q;
    int len = length_list(pHead);

    for (i = 0, p = pHead->pNext; i < len - 1; ++i, p = p->pNext)
    {
        for (j = j + 1, q = p->pNext; j < len; ++j, q = q->pNext)
        {
            if (p->data > q->data) //类似于数组中的：a[i]>a[j]
            {
                t = p->data;       //类似于数组中的：t = a[i];
                p->data = q->data; //类似于数组中的：a[i]=a[j]
                q->data = t;       //类似于数组中的：a[j]=t;
            }
        }
    }

    return;
}

/*
在pHead所指向链表的第pos（从1开始）个节点的前面插入一个新的节点，该节点的值是val
*/
bool insert_list(PNODE pHead, int pos, int val)
{
    int i = 0;
    PNODE p = pHead;

    while (NULL != p && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }

    if (i > pos - 1 || NULL == p)
    {
        return false;
    }

    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (NULL == pNew)
    {
        printf("动态分配内存失败！\n");
        exit(-1);
    }
    pNew->data = val;
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;

    return true;
}

/*
删除一个节点
*/
bool delete_list(PNODE pHead, int pos, int *pVal)
{
    int i = 0;
    PNODE p = pHead;

    while (NULL != p->pNext && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }

    if (i > pos - 1 || NULL == p->pNext)
    {
        return false;
    }

    PNODE q = p->pNext;
    *pVal = q->data;

    //删除p节点后面的节点
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL;

    return true;
}